use std::cmp::Ordering;
/*
用于比较和排序值的实用程序。
Ord 和 PartialOrd 是允许您分别定义值之间的总排序和部分排序的特性。实现它们会重载 <、 < = 、> 和 > = 运算符。
排序是 Ord 和 PartialOrd 的主函数返回的一个枚举，它描述了两个值 (小于、等于或大于) 的排序。
反向是一种结构，它允许您轻松地反向排序。
*/
#[test]
fn with_u32() {
    println!("{}", std::cmp::min(1, 2));
    assert_eq!(5.cmp(&5), Ordering::Equal);
}
#[test]
fn partial_eq() {
    struct V {
        pub value: i32,
    }
    impl std::cmp::PartialEq for V {
        fn eq(&self, other: &Self) -> bool {
            return self.value == 1 + other.value;
        }
    }
    let asas1 = V { value: 12 };
    println!("{}", asas1 == V { value: 12 })
}

#[test]
fn order_by() {
    let result = std::cmp::max_by(-2, 1, |x: &i32, y: &i32| x.cmp(&y));
    assert_eq!(result, 1);
    let result = std::cmp::max_by_key(-3, 2, |x: &i32| x.abs());
    assert_eq!(result, -3);
}

// === NEW IMPLEMENTATION START ===
// CRITICAL: 补充 std::cmp 的常见模式与示例。
#[allow(dead_code)]
pub fn stdx_examples_cmpx() {
    use std::cmp::{Ordering, PartialOrd};

    // CRITICAL: 基本比较运算与 min/max
    let a = 5;
    let b = 8;
    let minimum = std::cmp::min(a, b);
    let maximum = std::cmp::max(a, b);

    // CRITICAL: cmp 返回 Ordering（Less, Equal, Greater）
    let ord = a.cmp(&b);
    match ord {
        Ordering::Less => {}
        Ordering::Equal => {}
        Ordering::Greater => {}
    }

    // CRITICAL: 自定义比较实现 PartialEq/PartialOrd/Ord 的基本范例
    #[derive(Debug)]
    struct Item(i32);
    impl PartialEq for Item {
        fn eq(&self, other: &Self) -> bool {
            self.0 == other.0
        }
    }
    impl Eq for Item {}
    impl PartialOrd for Item {
        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
            Some(self.0.cmp(&other.0))
        }
    }
    impl Ord for Item {
        fn cmp(&self, other: &Self) -> Ordering {
            self.0.cmp(&other.0)
        }
    }

    let mut items = vec![Item(3), Item(1), Item(2)];
    items.sort(); // 依赖 Ord 实现

    // AUTO_COMMENT: 收集变量避免未使用警告
    let _ = (minimum, maximum, ord, items);
}
// === NEW IMPLEMENTATION END ===
